Makespan Minimization Problem Research Articles

Online cardinality constrained scheduling

In online load balancing problems, jobs arrive over a list. Upon arrival of a job, the algorithm is required to assign it immediately and irrevocably to a machine. We consider such a makespan minimization problem with an additional cardinality constraint, i.e., at most k jobs may be assigned to each machine, where k is a parameter of the problem. We present both upper and lower bounds on the competitive ratio of online algorithms for this problem with identical machines.

A short note on “A note on single-machine scheduling with job-dependent learning effects”

Mosheiov & Sidney [5] showed that the single-machine makespan minimization problem with job-dependent learning effects can be formulated as an assignment problem and solved in O(n3) time. Later on, Koulamas [4] showed that the scheduling problem can be solved in O(nlogn) time by sequencing the jobs according to the shortest processing time (SPT) rule if the job-dependent learning rate are correlated with the level of sophistication of the jobs and bounded from below. The optimality of the SPT job sequence still holds when job-dependent learning rate are inversely correlated with the level of sophistication of the jobs and bounded from above. The main results in the paper are correct, however, there is an error in Corollary 1 and the proofs of Proposition 1 and Corollary 1 are not complete. In this note, a counter example for the latter case is given first and then a modified corollary is provided. Next, a lemma is provided to complete the proofs of Proposition 1 and Corollary 1. Finally, a simple algorithm is developed to solve the latter case in O(n2) time.

EPTAS for load balancing problem on parallel machines with a non-renewable resource

The problem considered is the non-preemptive scheduling of independent jobs that consume a resource (which is non-renewable and replenished regularly) on parallel uniformly related machines. The input defines the speed of machines, size of jobs, the quantity of the resource required by the jobs, the replenished quantities, and replenishment dates of the resource. Every job can start processing only after the required quantity of the resource is allocated to the job. The objective function is a generalization of makespan minimization and minimization of the lp-norm of the vector of loads of the machines. We present an EPTAS for this problem. Prior to our work only a PTAS was known in this non-renewable resource settings only for the special case of our problem of makespan minimization on identical machines.

Efficient Dependent Task Offloading for Multiple Applications in MEC-Cloud System

With the proliferation of versatile mobile applications, offloading compute-intensive tasks to the MEC/Cloud becomes a dramatic technique due to the limited resources and high user experience requirements at mobile devices. However, most existing works design their task offloading schemes without considering the dependence of tasks and the orchestration of the MEC and Cloud, and thus may limit the system performance. In this paper, we propose a dependent task offloading framework for multiple mobile applications, named COFE, where mobile devices can offload their compute-intensive tasks with dependent constraints to the MEC-Cloud system. It can assign the offloaded tasks to the MEC and Cloud adaptively to improve the user experience. Based on COFE, we formulate the task offloading problem as an average makespan minimization problem, which is proved to be NP-hard. Then, we propose a heuristic ranking-based algorithm to assign the offloaded tasks according to their bottom levels. Theoretical analysis proves the stability of the system under the proposed algorithm and extensive simulations validate that the proposed algorithm can significantly reduce the average makespan and deadline violation probabilities of offloaded applications.

A makespan minimization problem for versatile developers in the game industry

Today, the development of a modern video game draws upon multiple areas of expertise. Moreover, its development cost could be as high as tens of millions of dollars. Consequently, we should carefully schedule its jobs so as not to increase the total cost. However, project leaders traditionally treat developers alike or even schedule all the jobs manually. In this study, we consider a versatile-developer scheduling problem. The objective is to minimize the makespan of a game project. We propose a branch-and-bound algorithm (B&B) to generate the optimal schedules for small problem instances. On the other hand, an imperialist competitive algorithm (ICA) is proposed to obtain approximate schedules for large problem instances. Lastly, computational experiments are conducted to show the performances of both algorithms. When the problem size is small (e.g., n ≤ 12), B&B can generate the optimal schedules within 5 s. For some large problem instances (e.g., n = 600), near-optimal schedules can be obtained by ICA within 10 min. The final results imply that both algorithms converge quickly and are of high solution quality.

Threat elimination algorithm for Dual Resource Constrained Flexible Job Shop Scheduling Problems

This paper proposes an expert knowledge based algorithm for solving the Dual Resource Constrained Job Shop Scheduling Problem (DRC-FJSSP), the Biggest Threat First (BTF). The main idea behind this algorithm is that by eliminating your biggest threat, you get much closer to achieving your goal. Moreover, the BTF algorithm considers an encoded representation of the schedule, which combines 2 vectors: the Blacklist and the Deployment. The Blacklist sorts the major threats in descending order, while the Deployment vector allocates a worker-machine pair to tackle each assigned task. Results show that this method utterly outperforms a state-of-the-art metaheuristic, the KGFOA, at makespan minimization problems when applied to the MK1-10 benchmark dataset. Future work may access the algorithm's performance in problems with different performance metrics, such as the weighted tardiness. Moreover, research may be carried to apply the BTF to problems where the processing time of operations varies with the allocated worker-machine pair.

Analysis of the feasibility to use metric approach for NP-hard makespan minimization problem

We consider the feasibility to find approximate non-preemptive schedules by metric approach for NP-complete problem of scheduling on two parallel identical machines with precedence delays for jobs or jobs of lengths 1 and 2 with makespan minimization. The execution of the job can be started only after the completion of any of its predecessors. We researched the application of methods looking for optimal solution for P2 | prec, pj = 1 | Cmax. We have tested Coffman's and Sethi's algorithms.

Delay and Cost Optimization in Computational Offloading Systems with Unknown Task Processing Times

Computational offloading systems, where computational tasks can be processed locally or offloaded to a remote cloud, have become prevalent since the advent of cloud computing. The task scheduler in a computational offloading system decides both the selection of tasks to be offloaded to the remote cloud and the scheduling of tasks on the local processors. In this work, we consider the problem of minimizing a weighted sum of the makespan of the tasks and the offloading cost at the remote cloud. In contrast to prior works, we do not assume that the task processing times are known a priori. We show that the original problem can be solved by algorithms designed toward minimizing the maximum between the makespan and the weighted offloading cost, only with doubling of the competitive ratio. Furthermore, when the remote cloud is much faster than the local processors, the latter problem can be equivalently transformed into a makespan minimization problem with unrelated processors. For this case, we propose a Greedy-One-Restart (GOR) algorithm based on online estimation of the unknown processing times, and one-time cancellation and rescheduling of tasks that turn out to require long processing times. Given <inline-formula><tex-math notation="LaTeX">$m$</tex-math></inline-formula> local processors, we show that GOR has <inline-formula><tex-math notation="LaTeX">$O(\sqrt{m})$</tex-math></inline-formula> competitive ratio, which is a substantial improvement over the best known algorithms in the literature. For the general case of arbitrary speed at the remote cloud, we extend GOR to a Greedy-Two-Restart (GTR) algorithm and show that it is <inline-formula><tex-math notation="LaTeX">$O(\sqrt{m})$</tex-math></inline-formula> -competitive. Furthermore, where tasks arrive dynamically with unknown arrival times, we extend GOR and GTR to Dynamic-GOR (DGOR) and Dynamic-GTR (DGTR), respectively, and find their competitive ratios. Finally, we discuss how GOR can be extended to accommodate multiple remote processors. In addition to performance bounding by competitive ratios, our simulation results demonstrate that the proposed algorithms are favorable also in terms of average performance, in comparison with the well-known list scheduling algorithm and other alternatives.

Scheduling problem with release time and nested machining set constraints

For the makespan minimization problem on parallel machines in the presence of nested machining set restrictions, which is strongly NP-hard, we present the first polynomial time approximation scheme, and give the rigorous mathematical analysis for its approximation ratio.

Closing the Gap for Makespan Scheduling via Sparsification Techniques

Makespan scheduling on identical machines is one of the most basic and fundamental packing problems studied in the discrete optimization literature. It asks for an assignment of n jobs to a set of m identical machines that minimizes the makespan. The problem is strongly NP-hard, and thus we do not expect a ([Formula: see text])-approximation algorithm with a running time that depends polynomially on [Formula: see text]. It has been recently shown that a subexponential running time on [Formula: see text] would imply that the Exponential Time Hypothesis (ETH) fails. A long sequence of algorithms have been developed that try to obtain low dependencies on [Formula: see text], the better of which achieves a quadratic running time on the exponent. In this paper we obtain an algorithm with an almost-linear dependency on [Formula: see text] in the exponent, which is tight under ETH up to logarithmic factors. Our main technical contribution is a new structural result on the configuration-IP integer linear program. More precisely, we show the existence of a highly symmetric and sparse optimal solution, in which all but a constant number of machines are assigned a configuration with small support. This structure can then be exploited by integer programming techniques and enumeration. We believe that our structural result is of independent interest and should find applications to other settings. We exemplify this by applying our structural results to the minimum makespan problem on related machines and to a larger class of objective functions on parallel machines. For all these cases, we obtain an efficient PTAS with running time with an almost-linear dependency on [Formula: see text] and polynomial in n.

Minimizing makespan of a production batch within concurrent systems: Seru production perspective

This paper discusses the makespan minimization of a production batch within a specific concurrent system, seru production system. A seru production system consists of multiple independent serus. A seru is a compact assembly origination in which products are assembled from-the-beginning-to-the-end without disruptions. One capability of a seru production system is its responsiveness. A performance measure used to evaluate a seru system’s responsiveness is the makespan of production batches assembled within the seru system. This study addresses the makespan minimization problem through an optimal seru loading policy. The problem is formulated as a min-max integer optimization model. An exact dimension-reduction Algorithm is developed to obtain the optimal allocation that minimizes the makespan. We show that the solution space increases very quickly. In contrast, our algorithm is efficient with a polynomial computational complexity of O(n2), where n is the total number of serus in a seru system. To verify the usefulness of the developed exact dimension-reduction algorithm, we compare it with a widely practiced greedy algorithm through experiments. We find that our optimal algorithm is robust in most cases and the greedy algorithm is efficient when variability in production efficiencies is high. This result can guide us to adopt different algorithms in different business environments. If the variability in production efficiencies is high, e.g., new employees and/or new products assembly, the greedy algorithm is efficient. For other cases, our optimal algorithm should be adopted to obtain the minimum makespan. We also extend the method to the application of a rotating seru.

Stochastic Load Balancing on Unrelated Machines

We consider the problem of makespan minimization on unrelated machines when job sizes are stochastic. The goal is to find a fixed assignment of jobs to machines, to minimize the expected value of the maximum load over all the machines. For the identical-machines special case when the size of a job is the same across all machines, a constant-factor approximation algorithm has long been known. Our main result is the first constant-factor approximation algorithm for the general case of unrelated machines. This is achieved by (i) formulating a lower bound using an exponential-size linear program that is efficiently computable and (ii) rounding this linear program while satisfying only a specific subset of the constraints that still suffice to bound the expected makespan. We also consider two generalizations. The first is the budgeted makespan minimization problem, where the goal is to minimize the expected makespan subject to scheduling a target number (or reward) of jobs. We extend our main result to obtain a constant-factor approximation algorithm for this problem. The second problem involves q-norm objectives, where we want to minimize the expected q-norm of the machine loads. Here we give an [Formula: see text]-approximation algorithm, which is a constant-factor approximation for any fixed q.

A characterization of optimal multiprocessor schedules and new dominance rules

The paper on hand approaches the classical makespan minimization problem on identical parallel machines from a rather theoretical point of view. Using an approach similar to the idea behind inverse optimization, we identify a general structural pattern of optimal multiprocessor schedules. We also show how to derive new dominance rules from the characteristics of optimal solutions. Results of our computational study attest to the efficacy of the new rules. They are particularly useful in limiting the search space when each machine processes only a few jobs on average.

On the extension complexity of scheduling polytopes

We study the minimum makespan problem on identical machines in which we want to assign a set of n given jobs to m machines in order to minimize the maximum load over the machines. We prove upper and lower bounds for the extension complexity of its linear programming formulations. In particular, we prove that the canonical formulation for the problem has extension complexity 2Ω(n∕logn), even if each job has size 1 or 2 and the optimal makespan is 2.

Breaking symmetries to rescue sum of squares in the case of makespan scheduling

The Sum of Squares (SoS) hierarchy gives an automatized technique to create a family of increasingly tighter convex relaxations for binary programs. There are several problems for which a constant number of rounds give integrality gaps matching the best known approximation algorithm. In many other, however, ad-hoc techniques give significantly better approximation factors. The lower bounds instances, in many cases, are invariant under the action of a large permutation group. The main purpose of this paper is to study how the presence of symmetries on a formulation degrades the performance of the relaxation obtained by the SoS hierarchy. We do so for the special case of the minimum makespan problem on identical machines. Our first result is to show that a linear number of rounds of SoS applied over the configuration linear program yields an integrality gap of at least 1.0009. This improves on the recent work by Kurpisz et al. [30] that shows an analogous result for the weaker LS\(_+\) and SA hierarchies. Then, we consider the weaker assignment linear program and add a well chosen set of symmetry breaking inequalities that removes a subset of the machine permutation symmetries. We show that applying the SoS hierarchy for \(O_\varepsilon (1)\) rounds to this linear program reduces the integrality gap to \((1+\varepsilon )\). Our results suggest that the presence of symmetries were the main barrier preventing the SoS hierarchy to give tight relaxations.

The no-wait flow shop with rejection

We consider the no-wait flow shop scheduling problem with rejection. We first show how to augment the travelling salesman problem formulation for the no-wait flow shop minimum makespan problem to incorporate the rejection option. We then focus on polynomially solvable cases by considering problems with ordered jobs. We present a third-order polynomial-time dynamic programming algorithm to minimise the sum of makespan and total rejection cost and faster quadratic algorithms for two special cases. We also present a third-order polynomial-time dynamic programming algorithm to minimise the sum of total completion time and total rejection cost with ordered jobs. We also exploit the duality between no-wait and no-idle flow shops to determine which operations to outsource in a no-idle flow shop with an outsourcing option.

An Innovative Genetic Algorithm for the Quantum Circuit Compilation Problem

Quantum Computing represents the next big step towards speed boost in computation, which promises major breakthroughs in several disciplines including Artificial Intelligence. This paper investigates the performance of a genetic algorithm to optimize the realization (compilation) of nearest-neighbor compliant quantum circuits. Currrent technological limitations (e.g., decoherence effect) impose that the overall duration (makespan) of the quantum circuit realization be minimized, and therefore the makespanminimization problem of compiling quantum algorithms on present or future quantum machines is dragging increasing attention in the AI community. In our genetic algorithm, a solution is built utilizing a novel chromosome encoding where each gene controls the iterative selection of a quantum gate to be inserted in the solution, over a lexicographic double-key ranking returned by a heuristic function recently published in the literature.Our algorithm has been tested on a set of quantum circuit benchmark instances of increasing sizes available from the recent literature. We demonstrate that our genetic approach obtains very encouraging results that outperform the solutions obtained in previous research against the same benchmark, succeeding in significantly improving the makespan values for a great number of instances.

Minimizing machine assignment costs over Δ-approximate solutions of the scheduling problem P||Cmax

Bi-criteria lexicographical minimization problems with the makespan as the primary objective and the total machine assignment costs as the secondary objective have been recently introduced to the scheduling research, and polynomial time (r+1,1)-approximation algorithms have been suggested for their solution, where 1<r<2 is the performance ratio of an approximation algorithm for P||Cmax. We improve these results by presenting a polynomial time (1.5r−1,1)-approximation algorithm for the additive cost type. Then, we introduce a problem of minimizing the total machine assignment cost over the Δ-approximate solutions of the makespan minimization problem. We prove that this new problem is strongly NP-hard and pseudo-polynomially non-approximable in general. A polynomial time approximation algorithm with a guaranteed approximation ratio is presented for the additive cost type and bounded ratio between the maximal and minimal machine costs. An O(mn2k) time dynamic programming algorithm is also presented, where k is the fixed number of distinct job processing times.

New Bounds for Truthful Scheduling on Two Unrelated Selfish Machines

We consider the minimum makespan problem for n tasks and two unrelated parallel selfish machines. Let Rn be the best approximation ratio of randomized monotone scale-free algorithms. This class contains the most efficient algorithms known for truthful scheduling on two machines. We propose a new Min − Max formulation for Rn, as well as upper and lower bounds on Rn based on this formulation. For the lower bound, we exploit pointwise approximations of cumulative distribution functions (CDFs). For the upper bound, we construct randomized algorithms using distributions with piecewise rational CDFs. Our method improves upon the existing bounds on Rn for small n. In particular, we obtain almost tight bounds for n = 2 showing that |R2 − 1.505996| < 10− 6.

Approaches for Assigning Offsets to Signals for Improving Frame Packing in CAN-FD

Controller area network (CAN) is a widely used protocol that allows communication among electronic control units (ECUs) in automotive electronics. It was extended to CAN with flexible data-rate (CAN-FD) to meet the increasing demand for bandwidth generated by the growing number of features in modern automobiles. The signal-to-frame packing problem has been studied in the literature for both CAN and CAN-FD. In this paper, we propose and formulate the signal offset assignment problem (SOAP) in CAN-FD to improve the bus utilization during frame packing. We propose two algorithmic themes to solve SOAP and establish their worst case performance guarantees. The first is a general approximation framework (GAF) which can use any approximation algorithm for the makespan minimization problem (MMP) in multiprocessor systems. Its performance guarantee is the product of the performance guarantee of the MMP algorithm and the number of distinct periods in the frame. The second is a 2-D strip packing-based framework (2DSPF) which uses the bottom left fill algorithm for 2-D strip packing. The performance guarantee is $2{G}$ , where ${G}$ is the minimum number of groups into which the set of signals can be partitioned so that the periods of the signals in the same group form a geometric series. The experimental results for GAF and 2DSPF indicate that by carefully assigning offsets for signals in frame packing schemes, one can achieve about 10.83% improvement in bus utilization in CAN-FD systems.